#!/bin/bash
# ============================================================================
# distccd 自动配置脚本 - 用于配置远程编译机
# ============================================================================
#
# 功能：
#   1. 自动检测操作系统并安装 distcc
#   2. 配置 distccd 服务
#   3. 配置防火墙规则
#   4. 启动 distccd 服务
#
# 使用方法：
#   sudo ./ci/setup-distccd.sh [选项]
#
# 选项：
#   --allowed-nets NETS   允许的客户端网络（默认: 0.0.0.0/0，允许所有）
#   --jobs N              并行任务数（默认: CPU核心数 × 2）
#   --port PORT           监听端口（默认: 3632）
#   --help                显示帮助信息
#
# 示例：
#   sudo ./ci/setup-distccd.sh                              # 允许所有IP连接
#   sudo ./ci/setup-distccd.sh --allowed-nets 192.168.1.0/24  # 仅允许局域网
#
# ============================================================================

set -e

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

# 日志函数
log_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

log_header() {
    echo ""
    echo -e "${BOLD}${CYAN}===================================================${NC}"
    echo -e "${BOLD}${CYAN}$1${NC}"
    echo -e "${BOLD}${CYAN}===================================================${NC}"
    echo ""
}

# 监控 distccd 服务
monitor_distccd() {
    log_header "distccd 服务实时监控"
    
    # 检查服务状态
    if ! systemctl is-active --quiet distccd 2>/dev/null; then
        log_error "distccd 服务未运行"
        log_info "启动服务: sudo systemctl start distccd"
        exit 1
    fi
    
    # 从systemd服务文件中读取端口配置，如果没有则使用默认值3632
    local PORT=$(grep -E '--port|--listen' /etc/systemd/system/distccd.service 2>/dev/null | grep -oE '[0-9]+' | head -1)
    PORT=${PORT:-3632}
    
    log_success "distccd 服务正在运行"
    log_info "实时监控编译任务（按 Ctrl+C 退出）"
    echo ""
    
    # 持续监控
    while true; do
        clear
        echo -e "${BOLD}${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo -e "${BOLD}${CYAN}  distccd 服务器监控 - $(hostname)${NC}"
        echo -e "${BOLD}${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo ""
        
        # 显示时间
        echo -e "${YELLOW}⏰ 时间: $(date '+%Y-%m-%d %H:%M:%S')${NC}"
        echo ""
        
        # 服务状态
        echo -e "${GREEN}📊 服务状态${NC}"
        
        # distccd 服务状态
        local distccd_status=$(systemctl is-active distccd 2>/dev/null || echo "inactive")
        if [ "$distccd_status" = "active" ]; then
            echo -e "  distccd (3632):      ${GREEN}● 运行中${NC}"
        else
            echo -e "  distccd (3632):      ${RED}● 已停止${NC}"
        fi
        
        # GCC 版本服务状态
        local version_status=$(systemctl is-active distcc-version 2>/dev/null || echo "inactive")
        if [ "$version_status" = "active" ]; then
            echo -e "  版本服务 (3633):    ${GREEN}● 运行中${NC}"
        else
            echo -e "  版本服务 (3633):    ${YELLOW}● 未启动${NC}"
        fi
        
        echo ""
        
        # 任务统计
        echo -e "${GREEN}📈 任务统计${NC}"
        
        # 统计编译进程（多种方法）
        local gcc_procs=0
        
        # 方法1: 统计 cc1/cc1plus（实际编译器后端）
        gcc_procs=$(ps aux 2>/dev/null | grep -E "cc1|cc1plus" | grep -v grep | wc -l)
        
        # 方法2: 如果方法1没找到，统计 gcc/g++ 进程
        if [ "$gcc_procs" -eq 0 ]; then
            gcc_procs=$(ps aux 2>/dev/null | grep -E "[^a-z]gcc[^a-z]|[^a-z]g\+\+[^a-z]" | grep -v grep | grep -v distccd | wc -l)
        fi
        
        # 清理空格和换行
        gcc_procs=$(echo "$gcc_procs" | tr -d '\n\r ' | grep -o '[0-9]*' || echo "0")
        gcc_procs=${gcc_procs:-0}
        
        # 统计网络连接（多种方法兼容）
        local connections=0
        # 方法1: 使用 ss 命令（优先，更准确）
        if command -v ss &> /dev/null; then
            connections=$(ss -tn 2>/dev/null | grep ":${PORT:-3632}" | grep ESTAB | wc -l | tr -d '\n\r ' || echo "0")
        fi
        # 方法2: 使用 netstat 命令（备选）
        if [ "$connections" -eq 0 ] || [ -z "$connections" ]; then
            # 尝试不同的 netstat 格式
            connections=$(netstat -tn 2>/dev/null | grep -E ":(3632|${PORT:-3632})" | grep -E "ESTABLISHED|ESTAB" | wc -l | tr -d '\n\r ' || echo "0")
        fi
        # 方法3: 使用 lsof 命令（如果可用）
        if [ "$connections" -eq 0 ] || [ -z "$connections" ]; then
            if command -v lsof &> /dev/null; then
                connections=$(lsof -iTCP:${PORT:-3632} -sTCP:ESTABLISHED 2>/dev/null | wc -l | tr -d '\n\r ' || echo "0")
            fi
        fi
        connections=${connections:-0}
        
        echo -e "  活动连接: ${BOLD}${connections}${NC}"
        echo -e "  编译进程: ${BOLD}${gcc_procs}${NC}"
        
        # 如果有编译任务，显示绿色；否则显示灰色
        if [ "$gcc_procs" -gt 0 ] 2>/dev/null; then
            echo -e "  ${GREEN}🔨 正在编译中...${NC}"
        else
            echo -e "  ${CYAN}💤 等待任务${NC}"
        fi
        echo ""
        
        # 资源使用
        echo -e "${GREEN}💻 资源使用${NC}"
        
        # CPU使用率（兼容不同系统，使用正确的计算方法）
        # 优先使用 /proc/stat 方法（最准确），与版本服务逻辑一致
        local cpu_usage=""
        local cpu_cores=$(nproc 2>/dev/null || echo "4")
        local load_avg=$(cat /proc/loadavg 2>/dev/null | awk '{print $1}' || echo "0")
        local stat_file="/tmp/distcc_monitor_cpu_stat_prev"
        
        # 方法1: 从 /proc/stat 计算（最可靠的方法，与版本服务一致）
        if [ -f /proc/stat ]; then
            if [ -f "$stat_file" ]; then
                # 读取上一次的统计
                local prev_line=$(cat "$stat_file" 2>/dev/null)
                if [ -n "$prev_line" ]; then
                    local prev_idle=$(echo "$prev_line" | awk '{print $5}')
                    local prev_iowait=$(echo "$prev_line" | awk '{print $6}')
                    local prev_total=$(echo "$prev_line" | awk '{sum=$2+$3+$4+$5+$6+$7+$8; print sum}')
                    
                    # 读取当前统计
                    local curr_line=$(grep '^cpu ' /proc/stat 2>/dev/null)
                    if [ -n "$curr_line" ]; then
                        local curr_idle=$(echo "$curr_line" | awk '{print $5}')
                        local curr_iowait=$(echo "$curr_line" | awk '{print $6}')
                        local curr_total=$(echo "$curr_line" | awk '{sum=$2+$3+$4+$5+$6+$7+$8; print sum}')
                        
                        # 计算差值（排除 iowait，因为它是等待 I/O，不是真正的 CPU 使用）
                        local idle_diff=$((curr_idle - prev_idle))
                        local iowait_diff=$((curr_iowait - prev_iowait))
                        local total_diff=$((curr_total - prev_total))
                        
                        if [ "$total_diff" -gt 0 ]; then
                            # CPU 使用率 = (1 - (idle + iowait) / total) * 100
                            local idle_ratio=$(awk "BEGIN {printf \"%.4f\", ($idle_diff + $iowait_diff) / $total_diff}")
                            cpu_usage=$(awk "BEGIN {printf \"%.1f\", (1 - $idle_ratio) * 100}")
                        fi
                        
                        # 保存当前统计供下次使用
                        echo "$curr_line" > "$stat_file"
                    fi
                fi
            else
                # 首次运行，保存当前统计（下次调用时才能计算）
                grep '^cpu ' /proc/stat > "$stat_file" 2>/dev/null || true
                # 首次运行无法计算，使用 load average 作为近似值
                cpu_usage=$(awk "BEGIN {usage=($load_avg / $cpu_cores) * 100; if (usage > 100) usage=100; printf \"%.1f\", usage}")
            fi
        fi
        
        # 方法2: 如果 /proc/stat 方法失败，尝试其他方法
        if [ -z "$cpu_usage" ] || [ "$cpu_usage" = "0" ] || [ "$cpu_usage" = "0.0" ]; then
            # 使用 vmstat（如果可用）
            if command -v vmstat &> /dev/null; then
                cpu_usage=$(timeout 3 vmstat 1 2 2>/dev/null | tail -1 | awk '{printf "%.1f", 100 - $15}')
            fi
        fi
        
        # 方法3: 使用 mpstat（如果可用）
        if [ -z "$cpu_usage" ] || [ "$cpu_usage" = "0" ] || [ "$cpu_usage" = "0.0" ]; then
            if command -v mpstat &> /dev/null; then
                cpu_usage=$(mpstat 1 1 2>/dev/null | tail -1 | awk '{printf "%.1f", 100 - $NF}')
            fi
        fi
        
        # 方法4: 使用 top 命令（备选，可能不准确）
        if [ -z "$cpu_usage" ] || [ "$cpu_usage" = "0" ] || [ "$cpu_usage" = "0.0" ]; then
            if command -v top &> /dev/null; then
                if top -bn1 2>/dev/null | grep -q "%Cpu"; then
                    # 新版本 top 格式: %Cpu(s): 12.5 us, 5.2 sy, ...
                    local top_us=$(top -bn1 2>/dev/null | grep "%Cpu" | awk -F'[,%]' '{for(i=1;i<=NF;i++){if($i~/^[[:space:]]*[0-9]+\.[0-9]+[[:space:]]*us/){gsub(/[^0-9.]/,"",$i); print $i; exit}}')
                    local top_sy=$(top -bn1 2>/dev/null | grep "%Cpu" | awk -F'[,%]' '{for(i=1;i<=NF;i++){if($i~/^[[:space:]]*[0-9]+\.[0-9]+[[:space:]]*sy/){gsub(/[^0-9.]/,"",$i); print $i; exit}}')
                    if [ -n "$top_us" ] && [ -n "$top_sy" ]; then
                        cpu_usage=$(awk "BEGIN {printf \"%.1f\", $top_us + $top_sy}")
                    fi
                elif top -bn1 2>/dev/null | grep -q "Cpu(s)"; then
                    # 旧版本 top 格式
                    cpu_usage=$(top -bn1 2>/dev/null | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1 | tr -d '%')
                fi
            fi
        fi
        
        # 最后备选：使用 load average 作为近似值
        if [ -z "$cpu_usage" ] || [ "$cpu_usage" = "0" ] || [ "$cpu_usage" = "0.0" ]; then
            # load average 不是真正的 CPU 使用率，只是系统负载的近似值
            cpu_usage=$(awk "BEGIN {usage=($load_avg / $cpu_cores) * 100; if (usage > 100) usage=100; printf \"%.1f\", usage}")
        fi
        
        # 限制范围 0-100
        cpu_usage=${cpu_usage:-"N/A"}
        if [ "$cpu_usage" != "N/A" ]; then
            # 确保是数字且范围正确（使用awk进行范围检查）
            cpu_usage=$(echo "$cpu_usage" | awk '{if ($1 < 0) $1=0; if ($1 > 100) $1=100; printf "%.1f", $1}')
        fi
        
        # 内存使用率
        local mem_usage=$(free 2>/dev/null | grep Mem | awk '{printf("%.1f", $3/$2 * 100.0)}' || echo "N/A")
        
        # 系统负载
        local load_avg=$(uptime 2>/dev/null | awk -F'load average:' '{print $2}' | sed 's/^[[:space:]]*//' || echo "N/A")
        
        if [ "$cpu_usage" != "N/A" ]; then
            echo -e "  CPU: ${cpu_usage}%"
        else
            echo -e "  CPU: ${CYAN}(检测中...)${NC}"
        fi
        echo -e "  内存: ${mem_usage}%"
        echo -e "  负载: ${load_avg}"
        echo ""
        
        # 网络连接详情
        if [ "${connections:-0}" -gt 0 ] 2>/dev/null; then
            echo -e "${GREEN}🌐 客户端连接${NC}"
            # 使用临时文件避免管道中的子shell问题
            local temp_connections=$(mktemp)
            local port="${PORT:-3632}"
            
            # 方法1: 使用 ss 命令（优先）
            if command -v ss &> /dev/null; then
                ss -tn 2>/dev/null | grep ":${port}" | grep ESTAB > "$temp_connections" || true
            fi
            
            # 方法2: 使用 netstat 命令（备选）
            if [ ! -s "$temp_connections" ]; then
                netstat -tn 2>/dev/null | grep -E ":(3632|${port})" | grep -E "ESTABLISHED|ESTAB" > "$temp_connections" || true
            fi
            
            # 方法3: 使用 lsof 命令（如果可用）
            if [ ! -s "$temp_connections" ] && command -v lsof &> /dev/null; then
                lsof -iTCP:${port} -sTCP:ESTABLISHED 2>/dev/null | awk 'NR>1 {print $9}' | cut -d':' -f1 | sort -u > "$temp_connections" || true
            fi
            
            if [ -s "$temp_connections" ]; then
                while IFS= read -r line; do
                    # 尝试从不同格式提取客户端IP
                    client_ip=$(echo "$line" | awk '{print $5}' | cut -d':' -f1)
                    # 如果上面没提取到，尝试其他字段
                    if [ -z "$client_ip" ]; then
                        client_ip=$(echo "$line" | awk '{print $NF}' | cut -d':' -f1)
                    fi
                    if [ -n "$client_ip" ] && [ "$client_ip" != "Address" ]; then
                        echo -e "  ← ${MAGENTA}${client_ip}${NC}"
                    fi
                done < "$temp_connections"
            else
                echo -e "  ${CYAN}(暂无活动连接)${NC}"
            fi
            rm -f "$temp_connections"
            echo ""
        fi
        
        # 正在编译的文件（增强版）
        if [ "${gcc_procs:-0}" -gt 0 ] 2>/dev/null; then
            echo -e "${GREEN}📝 正在编译的文件${NC}"
            
            # 使用临时文件存储找到的文件
            local temp_files=$(mktemp)
            local temp_details=$(mktemp)
            
            # 从 /proc 读取编译器进程，提取输出文件名（.o文件）
            for pid in $(pgrep cc1 2>/dev/null) $(pgrep cc1plus 2>/dev/null); do
                if [ -f "/proc/$pid/cmdline" ]; then
                    # 读取完整命令行（保持空格分隔）
                    cmdline=$(tr '\0' ' ' < "/proc/$pid/cmdline" 2>/dev/null)
                    
                    # 方法1: 提取 -o 参数后的输出文件（.o文件）
                    output_file=$(echo "$cmdline" | grep -oP '\-o\s+\K[^\s]+\.o' | head -1)
                    
                    if [ -n "$output_file" ]; then
                        # 从 .o 文件名推断源文件名
                        # 例如: /path/to/NFServerLogicModule.cpp.o -> NFServerLogicModule.cpp
                        base=$(basename "$output_file" .o)
                        
                        # 如果文件名包含路径分隔符，取最后一部分
                        base=$(echo "$base" | sed 's/.*\///')
                        
                        # 如果看起来像是临时文件（包含随机字符），标记为临时
                        if echo "$base" | grep -qE 'distccd_[a-f0-9]+'; then
                            echo "TEMP" >> "$temp_details"
                        else
                            echo "$base" >> "$temp_details"
                        fi
                    else
                        # 方法2: 从命令行中提取输入文件（.ii或.c/cpp）
                        input_file=$(echo "$cmdline" | grep -oE '[^\s]+\.(ii|c|cpp|cc|cxx|C|CPP)' | head -1)
                        
                        if [ -n "$input_file" ]; then
                            base=$(basename "$input_file")
                            # 如果是临时 .ii 文件
                            if echo "$base" | grep -qE 'distccd_[a-f0-9]+\.ii'; then
                                echo "TEMP" >> "$temp_details"
                            else
                                echo "$base" >> "$temp_details"
                            fi
                        else
                            # 无法提取文件信息
                            echo "TEMP" >> "$temp_details"
                        fi
                    fi
                fi
            done
            
            # 统计临时文件和真实文件
            local temp_count=$(grep -c "^TEMP$" "$temp_details" 2>/dev/null || echo "0")
            # 清理空格和换行符，确保是纯数字
            temp_count=$(echo "$temp_count" | tr -d '\n\r ' | grep -o '[0-9]*' | head -1)
            temp_count=${temp_count:-0}
            
            local real_files=$(grep -v "^TEMP$" "$temp_details" 2>/dev/null)
            
            # 显示找到的文件
            if [ -n "$real_files" ]; then
                # 有真实文件名，显示出来（去重并限制数量）
                echo "$real_files" | sort -u | head -5 | while IFS= read -r file; do
                    if [ -n "$file" ]; then
                        echo -e "  🔨 ${YELLOW}${file}${NC}"
                    fi
                done
                
                # 如果还有更多临时文件
                if [ "$temp_count" -gt 0 ] 2>/dev/null; then
                    echo -e "  ${CYAN}   ... 另有 ${temp_count} 个编译任务${NC}"
                fi
            else
                # 只有临时文件，显示统计
                echo -e "  ${CYAN}🔨 编译中... (${gcc_procs} 个任务)${NC}"
                echo -e "  ${CYAN}   处理预处理后的临时文件${NC}"
            fi
            
            # 清理临时文件
            rm -f "$temp_files" "$temp_details"
            echo ""
        fi
        
        echo -e "${BOLD}${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo -e "${YELLOW}💡 提示: 主编译机运行 build.sh 启动时会提示监控脚本路径${NC}"
        echo -e "${YELLOW}   例如: /tmp/distcc_monitor_<PID>.sh${NC}"
        echo -e "${BOLD}${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        
        sleep 2
    done
}

# 显示帮助信息
show_help() {
    cat << EOF
distccd 远程编译服务器配置和管理脚本

使用方法:
    sudo $0 [命令] [选项]

命令:
    (无)          配置并启动 distccd 服务（默认）
    monitor       实时监控编译服务器状态 ⭐
    status        查看服务状态
    start         启动服务
    stop          停止服务
    restart       重启服务

配置选项（用于首次配置）:
    --allowed-nets NETS   允许的客户端网络（默认: 0.0.0.0/0，允许所有）
    --jobs N              并行任务数（默认: CPU核心数 × 2）
    --port PORT           监听端口（默认: 3632）
    --help, -h            显示帮助信息

示例:
    # 首次配置（全自动）
    sudo $0

    # 实时监控编译任务 ⭐
    sudo $0 monitor

    # 查看服务状态
    sudo $0 status

    # 重启服务
    sudo $0 restart

    # 自定义配置
    sudo $0 --allowed-nets 192.168.1.0/24 --jobs 32

说明:
    - monitor 命令可实时查看远程编译任务
    - 默认允许所有IP连接（0.0.0.0/0），适合内网环境
    - 并行任务数建议设为 CPU核心数 × 2
    - 端口默认为 3632（distcc 标准端口）

EOF
}

# 检查是否以 root 运行
check_root() {
    if [ "$EUID" -ne 0 ]; then
        log_error "请使用 sudo 运行此脚本"
        exit 1
    fi
}

# 检测操作系统
detect_os() {
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        OS=$ID
        OS_VERSION=$VERSION_ID
    elif [ -f /etc/redhat-release ]; then
        OS="centos"
    else
        log_error "无法检测操作系统"
        exit 1
    fi
    
    log_info "检测到操作系统: $OS $OS_VERSION"
}

# 获取 CPU 核心数
get_cpu_cores() {
    if [ -f /proc/cpuinfo ]; then
        nproc
    else
        echo "4"
    fi
}

# 从源码安装 distcc
install_distcc_from_source() {
    local DISTCC_VERSION="3.4"
    local INSTALL_DIR="/usr/local"
    
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    log_info "开始从源码编译安装 distcc ${DISTCC_VERSION}..."
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
    # 1. 安装编译依赖
    log_info "安装编译依赖..."
    case "$OS" in
        ubuntu|debian)
            apt-get install -y -qq gcc g++ make automake autoconf python3-dev wget curl \
                libiberty-dev binutils-dev || {
                log_error "依赖安装失败"
                return 1
            }
            ;;
        centos|rhel|rocky|almalinux)
            # CentOS 需要安装 binutils-devel（包含 libiberty）
            yum install -y -q gcc gcc-c++ make automake autoconf python3-devel wget curl \
                binutils-devel || {
                log_error "依赖安装失败"
                return 1
            }
            ;;
    esac
    
    # 2. 下载源码
    log_info "下载 distcc ${DISTCC_VERSION} 源码..."
    cd /tmp
    rm -rf distcc-${DISTCC_VERSION}*
    
    local download_success=0
    
    # 尝试从 GitHub 下载
    if wget -q --timeout=10 "https://github.com/distcc/distcc/releases/download/v${DISTCC_VERSION}/distcc-${DISTCC_VERSION}.tar.gz" 2>/dev/null; then
        download_success=1
        log_success "从 GitHub 下载成功"
    fi
    
    # 尝试备用源
    if [ $download_success -eq 0 ]; then
        log_warning "从 GitHub 下载失败，尝试备用源..."
        if curl -L -s -o distcc-${DISTCC_VERSION}.tar.gz "https://distcc.github.io/distcc-${DISTCC_VERSION}.tar.gz" 2>/dev/null; then
            download_success=1
            log_success "从备用源下载成功"
        fi
    fi
    
    if [ $download_success -eq 0 ]; then
        log_error "源码下载失败"
        log_info "你可以手动下载并放置到: /tmp/distcc-${DISTCC_VERSION}.tar.gz"
        return 1
    fi
    
    # 3. 解压
    log_info "解压源码..."
    tar -xzf distcc-${DISTCC_VERSION}.tar.gz || {
        log_error "解压失败"
        return 1
    }
    cd distcc-${DISTCC_VERSION}
    
    # 4. 配置
    log_info "配置编译选项..."
    ./configure --prefix=${INSTALL_DIR} \
        --sysconfdir=/etc \
        --with-python=/usr/bin/python3 &> /tmp/distcc-configure.log || {
        log_error "配置失败，查看日志: /tmp/distcc-configure.log"
        return 1
    }
    
    # 5. 编译
    log_info "编译中（这可能需要几分钟）..."
    make -j$(nproc) &> /tmp/distcc-make.log || {
        log_error "编译失败，查看日志: /tmp/distcc-make.log"
        return 1
    }
    log_success "编译完成"
    
    # 6. 安装
    log_info "安装到 ${INSTALL_DIR}..."
    make install &> /tmp/distcc-install.log || {
        log_error "安装失败，查看日志: /tmp/distcc-install.log"
        return 1
    }
    
    # 7. 创建符号链接
    log_info "创建符号链接..."
    ln -sf ${INSTALL_DIR}/bin/distcc /usr/bin/distcc
    ln -sf ${INSTALL_DIR}/bin/distccd /usr/bin/distccd
    
    # 8. 验证安装
    if command -v distcc &> /dev/null && command -v distccd &> /dev/null; then
        local distcc_ver=$(distcc --version 2>&1 | head -n1)
        local distccd_ver=$(distccd --version 2>&1 | head -n1)
        log_success "✅ distcc 从源码安装成功"
        log_info "  distcc:  $distcc_ver"
        log_info "  distccd: $distccd_ver"
    else
        log_error "安装验证失败"
        return 1
    fi
    
    # 9. 清理
    log_info "清理临时文件..."
    cd /tmp
    rm -rf distcc-${DISTCC_VERSION}*
    
    return 0
}

# 诊断 distcc 包问题
diagnose_distcc_package() {
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    log_info "诊断 distcc 包..."
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
    if command -v rpm &> /dev/null && rpm -q distcc &> /dev/null; then
        log_info "distcc 包信息:"
        rpm -qi distcc | grep -E '^(Name|Version|Release)' || true
        
        log_info ""
        log_info "distcc 包文件列表:"
        local has_distccd=0
        rpm -ql distcc | while read file; do
            if [[ "$file" == *"distccd"* ]]; then
                has_distccd=1
                if [ -f "$file" ]; then
                    echo "  ✅ $file"
                    if [ -x "$file" ]; then
                        echo "     可执行: 是"
                    else
                        echo "     可执行: 否"
                    fi
                fi
            fi
        done
        
        if [ $has_distccd -eq 0 ]; then
            log_warning "❌ distcc 包不包含 distccd 服务端"
            log_info "CentOS 7 的 distcc 包可能只包含客户端"
            return 1
        fi
    elif command -v dpkg &> /dev/null && dpkg -l distcc &> /dev/null 2>&1; then
        log_info "distcc 包信息:"
        dpkg -l distcc | grep ^ii || true
        
        log_info ""
        log_info "distcc 包文件列表:"
        dpkg -L distcc | grep distccd || true
    fi
    
    return 0
}

# 安装 distcc（智能安装）
install_distcc() {
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    log_info "开始安装 distcc..."
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
    # 步骤 1: 尝试用包管理器安装
    log_info "步骤 1/3: 尝试从包管理器安装..."
    
    case "$OS" in
        ubuntu|debian)
            apt-get update -qq
            apt-get install -y -qq distcc gcc g++ build-essential socat 2>&1 | grep -v "^Get:" || true
            ;;
        centos|rhel|rocky|almalinux)
            # 先尝试启用 EPEL
            if ! rpm -q epel-release &> /dev/null; then
                log_info "启用 EPEL 仓库..."
                yum install -y -q epel-release 2>&1 | grep -v "^Package" || true
            fi
            yum install -y -q distcc gcc gcc-c++ make socat 2>&1 | grep -v "^Package" || true
            ;;
        *)
            log_error "不支持的操作系统: $OS"
            exit 1
            ;;
    esac
    
    # 验证 socat 安装（用于 GCC 版本服务）
    if command -v socat &> /dev/null; then
        log_success "✅ socat 已安装（用于 GCC 版本服务）"
    else
        log_warning "⚠️  socat 未安装，GCC 版本服务将使用备用方案（nc）"
    fi
    
    # 步骤 2: 验证是否有 distccd
    log_info "步骤 2/3: 验证 distccd 是否可用..."
    
    if command -v distccd &> /dev/null; then
        local version=$(distccd --version 2>&1 | head -n1)
        log_success "✅ distcc 包管理器安装成功: $version"
        return 0
    fi
    
    # 检查包是否安装但 distccd 不存在
    if rpm -q distcc &> /dev/null || dpkg -l distcc &> /dev/null 2>&1; then
        log_warning "distcc 包已安装，但未找到 distccd 命令"
        
        # 尝试查找 distccd
        local distccd_path=""
        if command -v rpm &> /dev/null; then
            distccd_path=$(rpm -ql distcc 2>/dev/null | grep -E 'distccd$' | head -n1 || true)
        elif command -v dpkg &> /dev/null; then
            distccd_path=$(dpkg -L distcc 2>/dev/null | grep -E 'distccd$' | head -n1 || true)
        fi
        
        if [ -n "$distccd_path" ] && [ -x "$distccd_path" ]; then
            log_success "找到 distccd: $distccd_path"
            # 创建符号链接
            ln -sf "$distccd_path" /usr/bin/distccd
            log_success "✅ distccd 已添加到 PATH"
            return 0
        else
            log_warning "distcc 包不包含 distccd 服务端"
            diagnose_distcc_package || true
        fi
    fi
    
    # 步骤 3: 从源码编译安装
    log_info "步骤 3/3: 从源码编译安装..."
    log_warning "包管理器的 distcc 不包含服务端，将从源码编译"
    
    if install_distcc_from_source; then
        log_success "✅ distcc 从源码安装成功"
        return 0
    else
        log_error "从源码安装也失败了"
        exit 1
    fi
}

# 创建 distcc 用户
create_distcc_user() {
    if id "distcc" &>/dev/null; then
        log_info "distcc 用户已存在"
    else
        log_info "创建 distcc 用户..."
        useradd -r -s /bin/false distcc
        log_success "distcc 用户创建成功"
    fi
}

# 设置 masquerade（编译器白名单）
setup_masquerade() {
    log_info "设置 distcc masquerade（编译器白名单）..."
    
    # 确定 masquerade 目录
    local masquerade_dir="/usr/local/lib/distcc"
    
    # 查找 distccd 路径
    local distccd_path=$(which distccd 2>/dev/null)
    if [ -z "$distccd_path" ]; then
        distccd_path="/usr/local/bin/distccd"
    fi
    
    if [ ! -x "$distccd_path" ]; then
        log_error "找不到 distccd: $distccd_path"
        return 1
    fi
    
    # 创建 masquerade 目录
    if [ ! -d "$masquerade_dir" ]; then
        mkdir -p "$masquerade_dir"
        log_info "创建 masquerade 目录: $masquerade_dir"
    fi
    
    # 检测编译器
    log_info "检测系统中安装的编译器..."
    
    # 检测 Clang 版本（优先）
    local clang_versions=""
    local clang_found=false
    local clang_default=""
    
    # 查找所有 clang 版本（clang-11, clang-12, ..., clang-18）
    for version in 11 12 13 14 15 16 17 18; do
        if command -v clang-${version} &> /dev/null; then
            clang_versions="${clang_versions} clang-${version}"
            if [ -z "$clang_default" ]; then
                clang_default="clang-${version}"
            fi
            clang_found=true
        fi
    done
    
    # 如果没有找到版本化的 clang，尝试默认的 clang
    if [ "$clang_found" = false ] && command -v clang &> /dev/null; then
        clang_default="clang"
        clang_found=true
        log_info "  找到默认 clang（未指定版本）"
    fi
    
    # 检测 GCC
    local gcc_found=false
    if command -v gcc &> /dev/null; then
        gcc_found=true
    fi
    
    # 创建编译器符号链接
    log_info "创建编译器符号链接..."
    
    # 确定主要编译器（优先 Clang，如果存在）
    local primary_compiler=""
    if [ "$clang_found" = true ]; then
        primary_compiler="clang"
    elif [ "$gcc_found" = true ]; then
        primary_compiler="gcc"
    fi
    
    # 优先配置 Clang（如果存在）
    if [ "$clang_found" = true ]; then
        log_info "配置 Clang 编译器（优先）..."
        
        # 配置版本化的 clang（clang-14 等）
        for version in 11 12 13 14 15 16 17 18; do
            if command -v clang-${version} &> /dev/null; then
                local link_path="$masquerade_dir/clang-${version}"
                if [ -L "$link_path" ] || [ -e "$link_path" ]; then
                    rm -f "$link_path"
                fi
                ln -s "$distccd_path" "$link_path"
                log_success "  ✅ clang-${version} -> $distccd_path"
                
                # 同时创建 clang++ 版本
                if command -v clang++-${version} &> /dev/null; then
                    local link_path_cxx="$masquerade_dir/clang++-${version}"
                    if [ -L "$link_path_cxx" ] || [ -e "$link_path_cxx" ]; then
                        rm -f "$link_path_cxx"
                    fi
                    ln -s "$distccd_path" "$link_path_cxx"
                    log_success "  ✅ clang++-${version} -> $distccd_path"
                fi
            fi
        done
        
        # 配置默认 clang（如果存在）
        if command -v clang &> /dev/null; then
            local link_path="$masquerade_dir/clang"
            if [ -L "$link_path" ] || [ -e "$link_path" ]; then
                rm -f "$link_path"
            fi
            ln -s "$distccd_path" "$link_path"
            log_success "  ✅ clang -> $distccd_path"
            
            # 同时创建 clang++
            if command -v clang++ &> /dev/null; then
                local link_path_cxx="$masquerade_dir/clang++"
                if [ -L "$link_path_cxx" ] || [ -e "$link_path_cxx" ]; then
                    rm -f "$link_path_cxx"
                fi
                ln -s "$distccd_path" "$link_path_cxx"
                log_success "  ✅ clang++ -> $distccd_path"
            fi
        fi
        
        log_info "  💡 建议：在主编译机的 build.sh 中使用相同的 Clang 版本"
        if [ -n "$clang_default" ]; then
            log_info "  💡 检测到默认 Clang: $clang_default"
        fi
    else
        log_warning "  ⚠️  未找到 Clang 编译器"
        log_info "  💡 如果主编译机使用 Clang，建议在远程服务器安装相同版本"
        log_info "  💡 安装示例: sudo apt-get install clang-14  # 或 yum install clang"
    fi
    
    # 配置 GCC（作为备选，但很重要！）
    if [ "$gcc_found" = true ]; then
        log_info "配置 GCC 编译器（备选，但必需）..."
        for compiler in gcc g++; do
            if command -v $compiler &> /dev/null; then
                local link_path="$masquerade_dir/$compiler"
                if [ -L "$link_path" ] || [ -e "$link_path" ]; then
                    rm -f "$link_path"
                fi
                ln -s "$distccd_path" "$link_path"
                log_success "  ✅ $compiler -> $distccd_path"
            fi
        done
        log_info "  💡 GCC 已配置，客户端可以使用 GCC 编译"
    else
        log_warning "  ⚠️  未找到 GCC 编译器"
        log_warning "  ⚠️  如果客户端使用 GCC（USE_CLANG=0），编译将失败！"
        log_info "  💡 建议安装 GCC: sudo apt-get install gcc g++"
    fi
    
    # 配置通用编译器别名（cc, c++）
    # 注意：这些别名应该指向主要编译器，确保一致性
    log_info "配置通用编译器别名（指向主要编译器）..."
    if [ "$primary_compiler" = "clang" ] && [ "$clang_found" = true ]; then
        # 如果主要编译器是 Clang，让 cc/c++ 指向 clang/clang++
        local clang_default_cmd=""
        if [ -n "$clang_default" ]; then
            clang_default_cmd="$clang_default"
        elif command -v clang &> /dev/null; then
            clang_default_cmd="clang"
        fi
        
        if [ -n "$clang_default_cmd" ]; then
            # cc -> clang
            local link_path="$masquerade_dir/cc"
            if [ -L "$link_path" ] || [ -e "$link_path" ]; then
                rm -f "$link_path"
            fi
            ln -s "$distccd_path" "$link_path"
            log_success "  ✅ cc -> $distccd_path (将使用 ${clang_default_cmd})"
            
            # c++ -> clang++
            if command -v "${clang_default_cmd}++" &> /dev/null || command -v clang++ &> /dev/null; then
                local link_path_cxx="$masquerade_dir/c++"
                if [ -L "$link_path_cxx" ] || [ -e "$link_path_cxx" ]; then
                    rm -f "$link_path_cxx"
                fi
                ln -s "$distccd_path" "$link_path_cxx"
                log_success "  ✅ c++ -> $distccd_path (将使用 ${clang_default_cmd}++)"
            fi
        fi
    elif [ "$primary_compiler" = "gcc" ] && [ "$gcc_found" = true ]; then
        # 如果主要编译器是 GCC，让 cc/c++ 指向 gcc/g++
        for compiler in cc c++; do
            if command -v $compiler &> /dev/null; then
                local link_path="$masquerade_dir/$compiler"
                if [ -L "$link_path" ] || [ -e "$link_path" ]; then
                    rm -f "$link_path"
                fi
                ln -s "$distccd_path" "$link_path"
                log_success "  ✅ $compiler -> $distccd_path (将使用 gcc/g++)"
            fi
        done
    else
        # 如果都不存在，使用系统默认
        for compiler in cc c++; do
            if command -v $compiler &> /dev/null; then
                local link_path="$masquerade_dir/$compiler"
                if [ -L "$link_path" ] || [ -e "$link_path" ]; then
                    rm -f "$link_path"
                fi
                ln -s "$distccd_path" "$link_path"
                log_success "  ✅ $compiler -> $distccd_path"
            fi
        done
    fi
    
    # 设置权限
    chmod 755 "$masquerade_dir"
    
    log_success "masquerade 设置完成"
    log_info "白名单目录: $masquerade_dir"
    
    # 显示已创建的符号链接
    log_info "已启用的编译器:"
    ls -la "$masquerade_dir" | grep -v '^total' | grep -v '^d' || true
    
    # 显示编译器版本信息
    echo ""
    log_info "编译器版本信息:"
    if [ "$clang_found" = true ] && [ -n "$clang_default" ]; then
        local clang_cmd=$(command -v "$clang_default" 2>/dev/null || command -v clang 2>/dev/null)
        if [ -n "$clang_cmd" ]; then
            local clang_version=$($clang_cmd --version 2>/dev/null | head -n1 || echo "unknown")
            log_info "  Clang: $clang_version"
        fi
    fi
    if [ "$gcc_found" = true ]; then
        local gcc_version=$(gcc --version 2>/dev/null | head -n1 || echo "unknown")
        log_info "  GCC:   $gcc_version"
    fi
}

# 配置 systemd 服务
configure_systemd_service() {
    log_info "配置 systemd 服务..."
    
    # 查找 distccd 的实际路径
    local distccd_path=""
    
    # 方法 1: 使用 which 命令
    distccd_path=$(which distccd 2>/dev/null || true)
    
    # 方法 2: 从 rpm/dpkg 包查询（最可靠）
    if [ -z "$distccd_path" ]; then
        # CentOS/RHEL: 使用 rpm
        if command -v rpm &> /dev/null && rpm -q distcc &> /dev/null; then
            distccd_path=$(rpm -ql distcc 2>/dev/null | grep -E 'bin/distccd$|sbin/distccd$|libexec/distccd$' | head -n1 || true)
        fi
        
        # Ubuntu/Debian: 使用 dpkg
        if [ -z "$distccd_path" ] && command -v dpkg &> /dev/null; then
            distccd_path=$(dpkg -L distcc 2>/dev/null | grep -E 'bin/distccd$|sbin/distccd$|libexec/distccd$' | head -n1 || true)
        fi
    fi
    
    # 方法 3: 尝试常见位置
    if [ -z "$distccd_path" ]; then
        for path in /usr/bin/distccd /usr/local/bin/distccd /usr/sbin/distccd /usr/libexec/distccd; do
            if [ -x "$path" ]; then
                distccd_path="$path"
                break
            fi
        done
    fi
    
    # 方法 4: 使用 find 命令搜索（最后手段）
    if [ -z "$distccd_path" ]; then
        log_info "使用 find 搜索 distccd（这可能需要一些时间）..."
        distccd_path=$(find /usr -name distccd -type f -executable 2>/dev/null | head -n1 || true)
    fi
    
    # 验证是否找到
    if [ -z "$distccd_path" ]; then
        log_error "无法找到 distccd 可执行文件"
        log_info ""
        log_info "已尝试的查找方法:"
        log_info "  1. which distccd"
        log_info "  2. rpm/dpkg 包查询"
        log_info "  3. 常见路径检查"
        log_info "  4. find 搜索"
        log_info ""
        log_info "distcc 包可能已安装但文件列表异常"
        log_info ""
        log_info "建议操作:"
        if command -v rpm &> /dev/null; then
            log_info "  1. 查看 distcc 包内容: rpm -ql distcc"
            log_info "  2. 重新安装 distcc: yum reinstall -y distcc"
        else
            log_info "  1. 查看 distcc 包内容: dpkg -L distcc"
            log_info "  2. 重新安装 distcc: apt-get install --reinstall distcc"
        fi
        exit 1
    fi
    
    # 验证文件可执行
    if [ ! -x "$distccd_path" ]; then
        log_error "找到 distccd 但不可执行: $distccd_path"
        exit 1
    fi
    
    log_info "找到 distccd: $distccd_path"
    
    # 创建 systemd 服务文件
    # 注意：不使用 --daemon 参数，因为 systemd Type=simple 需要前台运行
    
    # 🔥 关键：不强制设置 CC/CXX，让 distccd 根据客户端请求的编译器自动选择
    # 检测所有可用的编译器路径，确保 PATH 中包含 Clang 和 GCC
    local compiler_dirs=""
    
    # 检测 Clang 编译器路径
    local clang_cmd=""
    for version in 14 15 16 17 18 13 12 11; do
        if command -v clang-${version} &> /dev/null; then
            clang_cmd="clang-${version}"
            break
        fi
    done
    if [ -z "$clang_cmd" ] && command -v clang &> /dev/null; then
        clang_cmd="clang"
    fi
    
    # 收集所有编译器目录
    # 🔥 关键：必须使用真实的编译器路径，不能使用 ccache 包装器！
    # 使用 env PATH="/usr/bin:/usr/local/bin" command -v 来绕过 ccache 包装器
    if [ -n "$clang_cmd" ]; then
        # 先尝试在标准路径中查找真实编译器（绕过 ccache）
        local clang_path=$(env PATH="/usr/bin:/usr/local/bin" command -v "$clang_cmd" 2>/dev/null)
        if [ -z "$clang_path" ]; then
            # 如果标准路径中没找到，再尝试完整 PATH
            clang_path=$(command -v "$clang_cmd" 2>/dev/null)
        fi
        
        if [ -n "$clang_path" ]; then
            local clang_dir=$(dirname "$clang_path")
            # 🔥 排除 ccache 包装器目录
            if [[ "$clang_dir" != *"ccache"* ]]; then
                if [ -n "$clang_dir" ] && [[ ":$compiler_dirs:" != *":$clang_dir:"* ]]; then
                    compiler_dirs="${compiler_dirs}:${clang_dir}"
                fi
                log_info "检测到 Clang: $clang_cmd ($clang_path)"
            else
                log_warning "⚠️  检测到 Clang 在 ccache 目录中: $clang_path（跳过，避免递归）"
                # 尝试查找真实的 clang
                local real_clang=$(find /usr/bin /usr/local/bin -name "$clang_cmd" -type f 2>/dev/null | head -n1)
                if [ -n "$real_clang" ]; then
                    local real_clang_dir=$(dirname "$real_clang")
                    if [ -n "$real_clang_dir" ] && [[ ":$compiler_dirs:" != *":$real_clang_dir:"* ]]; then
                        compiler_dirs="${compiler_dirs}:${real_clang_dir}"
                    fi
                    log_info "  找到真实 Clang: $real_clang"
                fi
            fi
        fi
    fi
    
    # 检测 GCC 编译器路径
    # 🔥 关键：必须使用真实的编译器路径，不能使用 ccache 包装器！
    if env PATH="/usr/bin:/usr/local/bin" command -v gcc &> /dev/null || command -v gcc &> /dev/null; then
        # 先尝试在标准路径中查找真实编译器（绕过 ccache）
        local gcc_path=$(env PATH="/usr/bin:/usr/local/bin" command -v gcc 2>/dev/null)
        if [ -z "$gcc_path" ]; then
            # 如果标准路径中没找到，再尝试完整 PATH
            gcc_path=$(command -v gcc 2>/dev/null)
        fi
        
        if [ -n "$gcc_path" ]; then
            local gcc_dir=$(dirname "$gcc_path")
            # 🔥 排除 ccache 包装器目录
            if [[ "$gcc_dir" != *"ccache"* ]]; then
                if [ -n "$gcc_dir" ] && [[ ":$compiler_dirs:" != *":$gcc_dir:"* ]]; then
                    compiler_dirs="${compiler_dirs}:${gcc_dir}"
                fi
                log_info "检测到 GCC: $gcc_path"
            else
                log_warning "⚠️  检测到 GCC 在 ccache 目录中: $gcc_path（跳过，避免递归）"
                # 尝试查找真实的 gcc
                local real_gcc=$(find /usr/bin /usr/local/bin -name gcc -type f 2>/dev/null | head -n1)
                if [ -n "$real_gcc" ]; then
                    local real_gcc_dir=$(dirname "$real_gcc")
                    if [ -n "$real_gcc_dir" ] && [[ ":$compiler_dirs:" != *":$real_gcc_dir:"* ]]; then
                        compiler_dirs="${compiler_dirs}:${real_gcc_dir}"
                    fi
                    log_info "  找到真实 GCC: $real_gcc"
                fi
            fi
        fi
    fi
    
    # 构建 PATH：包含所有编译器目录，然后是标准路径
    # 🔥 关键：确保 PATH 中不包含 ccache 包装器目录，避免递归调用！
    # 标准路径必须在最前面，确保找到真实的编译器
    local distcc_path="/usr/bin:/usr/local/bin"
    if [ -n "$compiler_dirs" ]; then
        # 移除开头的冒号
        compiler_dirs="${compiler_dirs#:}"
        # 确保编译器目录不包含 ccache
        local clean_compiler_dirs=""
        for dir in $(echo "$compiler_dirs" | tr ':' ' '); do
            if [[ "$dir" != *"ccache"* ]] && [ -n "$dir" ]; then
                if [ -z "$clean_compiler_dirs" ]; then
                    clean_compiler_dirs="$dir"
                else
                    clean_compiler_dirs="${clean_compiler_dirs}:${dir}"
                fi
            fi
        done
        
        if [ -n "$clean_compiler_dirs" ]; then
            # 将编译器目录添加到标准路径之后（标准路径优先）
            distcc_path="${distcc_path}:${clean_compiler_dirs}"
        fi
    fi
    
    # 🔥 关键：确保 PATH 中不包含任何 ccache 目录
    # 移除可能存在的 ccache 目录
    local final_path=""
    for dir in $(echo "$distcc_path" | tr ':' ' '); do
        if [[ "$dir" != *"ccache"* ]] && [ -n "$dir" ]; then
            if [ -z "$final_path" ]; then
                final_path="$dir"
            else
                final_path="${final_path}:${dir}"
            fi
        fi
    done
    distcc_path="$final_path"
    
    # 验证编译器是否在标准路径中可用
    if ! env PATH="/usr/bin:/usr/local/bin" command -v gcc &> /dev/null; then
        log_warning "⚠️  未找到 GCC 编译器，客户端使用 GCC 时可能失败"
        log_info "   建议安装 GCC: sudo apt-get install gcc g++"
    fi
    if ! env PATH="/usr/bin:/usr/local/bin" command -v clang &> /dev/null && [ -z "$clang_cmd" ]; then
        log_warning "⚠️  未找到 Clang 编译器，客户端使用 Clang 时可能失败"
        log_info "   建议安装 Clang: sudo apt-get install clang clang++"
    fi
    
    log_info "distccd PATH: ${distcc_path}"
    log_info "💡 提示: distccd 将根据客户端请求的编译器（gcc/clang）自动选择对应的编译器"
    log_info "💡 关键: PATH 中不包含 ccache 目录，避免递归调用"
    
    # 验证编译器是否在 PATH 中（使用 distccd 的 PATH）
    log_info "验证编译器可用性（使用 distccd PATH）:"
    if env PATH="${distcc_path}" command -v gcc &> /dev/null; then
        local gcc_ver=$(env PATH="${distcc_path}" gcc --version 2>/dev/null | head -n1 || echo "unknown")
        local gcc_real_path=$(env PATH="${distcc_path}" command -v gcc)
        log_info "  ✅ GCC: $gcc_ver"
        log_info "     路径: $gcc_real_path"
        # 检查是否是 ccache 包装器
        if [[ "$gcc_real_path" == *"ccache"* ]]; then
            log_error "  ❌ 错误: GCC 路径包含 ccache，会导致递归调用！"
            log_info "     请检查 PATH 配置"
        fi
    else
        log_warning "  ❌ GCC: 未找到（客户端使用 GCC 时会失败）"
    fi
    if [ -n "$clang_cmd" ]; then
        if env PATH="${distcc_path}" command -v "$clang_cmd" &> /dev/null; then
            local clang_ver=$(env PATH="${distcc_path}" "$clang_cmd" --version 2>/dev/null | head -n1 || echo "unknown")
            local clang_real_path=$(env PATH="${distcc_path}" command -v "$clang_cmd")
            log_info "  ✅ Clang: $clang_ver"
            log_info "     路径: $clang_real_path"
            # 检查是否是 ccache 包装器
            if [[ "$clang_real_path" == *"ccache"* ]]; then
                log_error "  ❌ 错误: Clang 路径包含 ccache，会导致递归调用！"
                log_info "     请检查 PATH 配置"
            fi
        else
            log_warning "  ❌ Clang: 未找到（客户端使用 Clang 时会失败）"
        fi
    else
        log_warning "  ❌ Clang: 未找到（客户端使用 Clang 时会失败）"
    fi
    
    # 生成 systemd 服务文件
    {
        cat << EOF
[Unit]
Description=Distcc Distributed Compiler Daemon
Documentation=man:distccd(1)
After=network.target

[Service]
Type=simple
User=distcc
Group=distcc
# 设置 PATH，包含所有编译器路径（Clang 和 GCC）
# 🔥 关键：不设置 CC/CXX，让 distccd 根据客户端请求自动选择编译器
Environment="PATH=${distcc_path}"
EOF
        cat << EOF
ExecStart=${distccd_path} \\
    --no-detach \\
    --log-stderr \\
    --log-level info \\
    --allow ${ALLOWED_NETS} \\
    --listen 0.0.0.0 \\
    --port ${PORT} \\
    --jobs ${JOBS} \\
    --nice 5

Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF
    } > /etc/systemd/system/distccd.service
    
    log_success "systemd 服务配置完成"
    log_info "使用 distccd 路径: ${distccd_path}"
    log_info "PATH: ${distcc_path}"
    log_info "配置要点:"
    log_info "  - Type=simple (前台运行)"
    log_info "  - 使用 --no-detach (不要后台化)"
    log_info "  - 日志输出到 systemd journal"
    log_info "  - PATH 包含所有编译器路径（Clang 和 GCC）"
    log_info "  - 不设置 CC/CXX，让 distccd 根据客户端请求自动选择编译器"

    # 创建 GCC 版本信息服务（端口 3633）
    create_gcc_version_service
}

# 创建 GCC 版本信息服务（持久运行的 TCP 守护进程）
create_gcc_version_service() {
    log_info "配置编译器版本信息服务（TCP 守护进程）..."

    # 检测主要编译器（优先 Clang，其次 GCC）
    local primary_compiler=""
    local primary_compiler_version=""
    local primary_compiler_major="unknown"
    
    # 优先检测 Clang
    local clang_cmd=""
    for version in 14 15 16 17 18 13 12 11; do
        if command -v clang-${version} &> /dev/null; then
            clang_cmd="clang-${version}"
            break
        fi
    done
    if [ -z "$clang_cmd" ] && command -v clang &> /dev/null; then
        clang_cmd="clang"
    fi
    
    if [ -n "$clang_cmd" ]; then
        primary_compiler="clang"
        local version_output=$($clang_cmd --version 2>/dev/null | head -n 1 || echo "clang: not found")
        primary_compiler_version="$version_output"
        
        # 改进 Clang 版本提取：专门匹配 "clang version X.Y.Z" 格式
        # 方法1: 精确匹配 "clang version X.Y.Z"（优先）
        primary_compiler_major=$(echo "$version_output" | grep -oE 'clang version [0-9]+\.[0-9]+\.[0-9]+' | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1)
        # 方法2: 如果没找到，尝试匹配 "clang version X.Y"
        if [ -z "$primary_compiler_major" ]; then
            primary_compiler_major=$(echo "$version_output" | grep -oE 'clang version [0-9]+\.[0-9]+' | grep -oE '[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1)
        fi
        # 方法3: 如果还是没找到，使用更宽松的匹配（但必须是第一个版本号）
        if [ -z "$primary_compiler_major" ]; then
            primary_compiler_major=$(echo "$version_output" | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1)
        fi
        
        # 如果还是没找到，使用 unknown
        if [ -z "$primary_compiler_major" ]; then
            primary_compiler_major="unknown"
        fi
        
        log_info "  检测到主要编译器: Clang ($primary_compiler_version)"
        log_info "  主版本号: ${primary_compiler_major}"
    elif command -v gcc &> /dev/null; then
        primary_compiler="gcc"
        primary_compiler_version=$(gcc --version 2>/dev/null | head -n 1 || echo "gcc: not found")
        primary_compiler_major=$(gcc --version 2>/dev/null | head -n 1 | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1 || echo "unknown")
        log_info "  检测到主要编译器: GCC ($primary_compiler_version)"
    else
        primary_compiler="gcc"
        primary_compiler_version="gcc: not found"
        primary_compiler_major="unknown"
        log_warning "  未找到编译器，使用默认值"
    fi
    
    # 获取 GCC 版本信息（作为备选信息）
    local gcc_version=$(gcc --version 2>/dev/null | head -n 1 || echo "gcc: not found")
    local gcc_major=$(gcc --version 2>/dev/null | head -n 1 | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1 || echo "unknown")

    # 创建版本信息文件
    mkdir -p /var/lib/distcc
    cat > /var/lib/distcc/version-info.txt << EOF
PRIMARY_COMPILER=${primary_compiler}
PRIMARY_COMPILER_VERSION=${primary_compiler_version}
PRIMARY_COMPILER_MAJOR=${primary_compiler_major}
GCC_VERSION=${gcc_version}
GCC_MAJOR=${gcc_major}
HOSTNAME=$(hostname)
TIMESTAMP=$(date +%s)
EOF

    # 创建 TCP 服务器脚本（使用 socat 或 nc 持久运行）
    cat > /usr/local/bin/distcc-version-server.sh << 'EOFSCRIPT'
#!/bin/bash
# GCC 版本信息 TCP 服务器

VERSION_FILE="/var/lib/distcc/version-info.txt"
PORT=3633

# 更新版本和负载信息（动态更新）
update_version_info() {
    # 检测主要编译器（优先 Clang）
    local primary_compiler="gcc"
    local primary_compiler_version=""
    local primary_compiler_major="unknown"
    
    # 检测 Clang
    local clang_cmd=""
    for version in 14 15 16 17 18 13 12 11; do
        if command -v clang-${version} &> /dev/null; then
            clang_cmd="clang-${version}"
            break
        fi
    done
    if [ -z "$clang_cmd" ] && command -v clang &> /dev/null; then
        clang_cmd="clang"
    fi
    
    if [ -n "$clang_cmd" ]; then
        primary_compiler="clang"
        local version_output=$($clang_cmd --version 2>/dev/null | head -n 1 || echo "clang: not found")
        primary_compiler_version="$version_output"
        
        # 改进 Clang 版本提取：专门匹配 "clang version X.Y.Z" 格式
        # 方法1: 精确匹配 "clang version X.Y.Z"（优先）
        primary_compiler_major=$(echo "$version_output" | grep -oE 'clang version [0-9]+\.[0-9]+\.[0-9]+' | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1)
        # 方法2: 如果没找到，尝试匹配 "clang version X.Y"
        if [ -z "$primary_compiler_major" ]; then
            primary_compiler_major=$(echo "$version_output" | grep -oE 'clang version [0-9]+\.[0-9]+' | grep -oE '[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1)
        fi
        # 方法3: 如果还是没找到，使用更宽松的匹配（但必须是第一个版本号）
        if [ -z "$primary_compiler_major" ]; then
            primary_compiler_major=$(echo "$version_output" | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1)
        fi
        
        # 如果还是没找到，使用 unknown
        if [ -z "$primary_compiler_major" ]; then
            primary_compiler_major="unknown"
        fi
    fi
    
    # 获取 GCC 版本信息（作为备选）
    local gcc_version=$(gcc --version 2>/dev/null | head -n 1 || echo "gcc: not found")
    local gcc_major=$(gcc --version 2>/dev/null | head -n 1 | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -n 1 | cut -d. -f1 || echo "unknown")
    
    # 获取 CPU 核心数
    local cpu_cores=$(nproc 2>/dev/null || echo "4")
    
    # 获取 1 分钟平均负载
    local load_avg=$(cat /proc/loadavg 2>/dev/null | awk '{print $1}' || echo "0")
    
    # 获取真实的 CPU 使用率（从 /proc/stat 计算，最可靠的方法）
    local cpu_usage="0"
    local stat_file="/tmp/distcc_cpu_stat_prev"
    
    if [ -f /proc/stat ]; then
        if [ -f "$stat_file" ]; then
            # 读取上一次的统计
            local prev_line=$(cat "$stat_file" 2>/dev/null)
            if [ -n "$prev_line" ]; then
                local prev_idle=$(echo "$prev_line" | awk '{print $5}')
                local prev_iowait=$(echo "$prev_line" | awk '{print $6}')
                local prev_total=$(echo "$prev_line" | awk '{sum=$2+$3+$4+$5+$6+$7+$8; print sum}')
                
                # 读取当前统计
                local curr_line=$(grep '^cpu ' /proc/stat 2>/dev/null)
                if [ -n "$curr_line" ]; then
                    local curr_idle=$(echo "$curr_line" | awk '{print $5}')
                    local curr_iowait=$(echo "$curr_line" | awk '{print $6}')
                    local curr_total=$(echo "$curr_line" | awk '{sum=$2+$3+$4+$5+$6+$7+$8; print sum}')
                    
                    # 计算差值（排除 iowait，因为它是等待 I/O，不是真正的 CPU 使用）
                    local idle_diff=$((curr_idle - prev_idle))
                    local iowait_diff=$((curr_iowait - prev_iowait))
                    local total_diff=$((curr_total - prev_total))
                    
                    if [ "$total_diff" -gt 0 ]; then
                        # CPU 使用率 = (1 - (idle + iowait) / total) * 100
                        local idle_ratio=$(awk "BEGIN {printf \"%.4f\", ($idle_diff + $iowait_diff) / $total_diff}")
                        cpu_usage=$(awk "BEGIN {printf \"%.0f\", (1 - $idle_ratio) * 100}")
                    fi
                    
                    # 保存当前统计供下次使用
                    echo "$curr_line" > "$stat_file"
                fi
            fi
        else
            # 首次运行，保存当前统计（下次调用时才能计算）
            grep '^cpu ' /proc/stat > "$stat_file" 2>/dev/null || true
            # 首次运行无法计算，使用 load average 作为近似值
            cpu_usage=$(awk "BEGIN {usage=($load_avg / $cpu_cores) * 100; if (usage > 100) usage=100; printf \"%.0f\", usage}")
        fi
    fi
    
    # 如果 /proc/stat 方法失败，尝试其他方法
    if [ -z "$cpu_usage" ] || [ "$cpu_usage" = "0" ]; then
        # 方法 2: 使用 vmstat（如果可用）
        if command -v vmstat &> /dev/null; then
            cpu_usage=$(timeout 3 vmstat 1 2 2>/dev/null | tail -1 | awk '{printf "%.0f", 100 - $15}')
        fi
    fi
    
    # 最后备选：使用 load average 作为近似值
    if [ -z "$cpu_usage" ] || [ "$cpu_usage" = "0" ]; then
        # load average 不是真正的 CPU 使用率，只是系统负载的近似值
        cpu_usage=$(awk "BEGIN {usage=($load_avg / $cpu_cores) * 100; if (usage > 100) usage=100; printf \"%.0f\", usage}")
    fi
    
    # 限制范围 0-100
    cpu_usage=${cpu_usage:-0}
    if [ "$cpu_usage" -lt 0 ]; then
        cpu_usage=0
    elif [ "$cpu_usage" -gt 100 ]; then
        cpu_usage=100
    fi
    
    # 获取内存使用率
    local mem_usage=$(free 2>/dev/null | grep Mem | awk '{printf("%.0f", $3/$2 * 100.0)}' || echo "0")
    
    # 获取当前活动编译任务数
    local active_jobs=$(ps aux 2>/dev/null | grep -E "cc1|cc1plus" | grep -v grep | wc -l | tr -d ' ')
    active_jobs=${active_jobs:-0}
    
    # 计算建议的并行任务数（基于负载的动态调整）
    # 如果负载低（<50%），建议满负载；如果负载高（>80%），减少任务
    local suggested_jobs=$cpu_cores
    if [ "$cpu_usage" -lt 50 ]; then
        suggested_jobs=$((cpu_cores * 2))  # 低负载：双倍
    elif [ "$cpu_usage" -gt 80 ]; then
        suggested_jobs=$((cpu_cores / 2))  # 高负载：减半
        [ "$suggested_jobs" -lt 1 ] && suggested_jobs=1
    fi
    
    mkdir -p /var/lib/distcc
    cat > "$VERSION_FILE" << EOF
PRIMARY_COMPILER=${primary_compiler}
PRIMARY_COMPILER_VERSION=${primary_compiler_version}
PRIMARY_COMPILER_MAJOR=${primary_compiler_major}
GCC_VERSION=${gcc_version}
GCC_MAJOR=${gcc_major}
HOSTNAME=$(hostname)
TIMESTAMP=$(date +%s)
CPU_CORES=${cpu_cores}
CPU_USAGE=${cpu_usage}
MEM_USAGE=${mem_usage}
LOAD_AVG=${load_avg}
ACTIVE_JOBS=${active_jobs}
SUGGESTED_JOBS=${suggested_jobs}
EOF
}

# 启动时更新版本信息
update_version_info

# 后台定期更新负载信息（每 5 秒更新一次）
(
    while true; do
        sleep 5
        update_version_info
    done
) &

# 使用最兼容的方式：while + nc（简单可靠）⭐⭐⭐⭐⭐
while true; do
    # 方法 1: 使用 socat（如果可用，最推荐）
    if command -v socat &> /dev/null; then
        socat TCP4-LISTEN:${PORT},reuseaddr,fork EXEC:"cat ${VERSION_FILE}" && continue
    fi
    
    # 方法 2: 使用 ncat（如果可用）
    if command -v ncat &> /dev/null; then
        cat "${VERSION_FILE}" | ncat -l ${PORT} && continue
    fi
    
    # 方法 3: 尝试不同的 nc 参数组合（兼容各种版本）
    if command -v nc &> /dev/null; then
        # OpenBSD nc (Ubuntu)
        cat "${VERSION_FILE}" | nc -l -p ${PORT} 2>/dev/null && continue
        # Traditional nc (CentOS)
        cat "${VERSION_FILE}" | nc -l ${PORT} 2>/dev/null && continue
        # Nmap ncat
        cat "${VERSION_FILE}" | nc -l ${PORT} -p ${PORT} 2>/dev/null && continue
    fi
    
    # 如果都失败，等待后重试
    sleep 1
done
EOFSCRIPT

    chmod +x /usr/local/bin/distcc-version-server.sh

    # 创建 systemd 服务（持久运行，不是 socket 激活）
    cat > /etc/systemd/system/distcc-version.service << EOF
[Unit]
Description=Distcc GCC Version Info TCP Server
Documentation=man:distccd(1)
After=network.target
PartOf=distccd.service

[Service]
Type=simple
ExecStart=/usr/local/bin/distcc-version-server.sh
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

    # 如果存在旧的 socket 配置，先停止并删除
    if [ -f /etc/systemd/system/distcc-version.socket ]; then
        systemctl stop distcc-version.socket 2>/dev/null || true
        systemctl disable distcc-version.socket 2>/dev/null || true
        rm -f /etc/systemd/system/distcc-version.socket
    fi

    # 重新加载 systemd 配置
    systemctl daemon-reload

    log_success "编译器版本信息服务配置完成"
    log_info "  主要编译器: ${primary_compiler} (${primary_compiler_version})"
    log_info "  主版本号: ${primary_compiler_major}"
    if [ "$primary_compiler" = "clang" ] && [ -n "$gcc_version" ]; then
        log_info "  GCC 备选: ${gcc_version} (主版本: ${gcc_major})"
    fi
    log_info "  TCP 端口: 3633"
    log_info "  服务类型: 持久运行的守护进程"
}

# 验证服务配置
verify_service_config() {
    log_info "验证服务配置..."
    
    # 1. 检查服务文件是否存在
    if [ ! -f /etc/systemd/system/distccd.service ]; then
        log_error "服务文件不存在"
        return 1
    fi
    
    # 2. 检查是否有冲突的参数（--daemon 和 --no-detach 冲突）
    if grep -q -- '--daemon' /etc/systemd/system/distccd.service; then
        log_warning "发现 --daemon 参数，这会导致启动失败"
        log_info "自动修复：移除 --daemon 参数..."
        
        # 创建临时文件
        local temp_file=$(mktemp)
        
        # 移除 --daemon 行
        grep -v -- '--daemon' /etc/systemd/system/distccd.service > "$temp_file"
        
        # 替换原文件
        mv "$temp_file" /etc/systemd/system/distccd.service
        
        log_success "已自动修复服务配置"
    fi
    
    # 3. 验证 distccd 路径
    local distccd_path=$(grep 'ExecStart=' /etc/systemd/system/distccd.service | awk '{print $1}' | cut -d= -f2)
    if [ ! -x "$distccd_path" ]; then
        log_error "distccd 路径不可执行: $distccd_path"
        return 1
    fi
    
    log_success "服务配置验证通过"
    return 0
}

# 配置防火墙
configure_firewall() {
    log_info "配置防火墙..."
    
    # firewalld (CentOS/RHEL)
    if command -v firewall-cmd &> /dev/null; then
        if systemctl is-active --quiet firewalld; then
            firewall-cmd --permanent --add-port=${PORT}/tcp &> /dev/null || true
            firewall-cmd --permanent --add-port=3633/tcp &> /dev/null || true  # GCC 版本信息服务
            firewall-cmd --reload &> /dev/null || true
            log_success "firewalld 规则已添加（端口 ${PORT} 和 3633）"
        else
            log_warning "firewalld 未运行，跳过防火墙配置"
        fi
    fi
    
    # ufw (Ubuntu/Debian)
    if command -v ufw &> /dev/null; then
        if ufw status | grep -q "Status: active"; then
            ufw allow ${PORT}/tcp &> /dev/null || true
            ufw allow 3633/tcp &> /dev/null || true  # GCC 版本信息服务
            log_success "ufw 规则已添加（端口 ${PORT} 和 3633）"
        else
            log_warning "ufw 未启用，跳过防火墙配置"
        fi
    fi
    
    # iptables (通用)
    if command -v iptables &> /dev/null; then
        # distccd 端口
        if ! iptables -C INPUT -p tcp --dport ${PORT} -j ACCEPT 2>/dev/null; then
            iptables -A INPUT -p tcp --dport ${PORT} -j ACCEPT
        fi
        # GCC 版本信息服务端口
        if ! iptables -C INPUT -p tcp --dport 3633 -j ACCEPT 2>/dev/null; then
            iptables -A INPUT -p tcp --dport 3633 -j ACCEPT
        fi
        log_success "iptables 规则已添加（端口 ${PORT} 和 3633）"
    fi
}

# 启动服务
start_service() {
    log_info "启动 distccd 服务..."
    
    # 1. 验证服务配置
    if ! verify_service_config; then
        log_warning "服务配置验证失败，但继续尝试启动..."
    fi
    
    # 2. 重新加载 systemd 配置
    systemctl daemon-reload
    
    # 3. 停止旧服务（如果在运行）
    if systemctl is-active --quiet distccd; then
        log_info "停止旧服务..."
        systemctl stop distccd || true
        sleep 1
    fi
    
    # 4. 停止旧的 GCC 版本服务（如果在运行）
    if systemctl is-active --quiet distcc-version 2>/dev/null; then
        log_info "停止旧的 GCC 版本服务..."
        systemctl stop distcc-version || true
    fi
    
    # 5. 启用并启动 distccd 服务
    systemctl enable distccd
    systemctl start distccd
    
    # 6. 启用并启动 GCC 版本信息服务
    log_info "启动 GCC 版本信息服务..."
    systemctl enable distcc-version
    systemctl start distcc-version
    
    # 7. 等待服务启动
    log_info "等待服务启动..."
    sleep 3
    
    # 8. 检查服务状态
    local retry=0
    local max_retry=3
    
    while [ $retry -lt $max_retry ]; do
        local distccd_ok=false
        local version_ok=false
        
        # 检查 distccd 服务
        if systemctl is-active --quiet distccd; then
            log_success "✅ distccd 服务启动成功"
            distccd_ok=true
            
            # 验证端口监听
            sleep 1
            if netstat -tuln 2>/dev/null | grep -q ":${PORT}" || ss -tuln 2>/dev/null | grep -q ":${PORT}"; then
                log_success "✅ distccd 正在监听端口 ${PORT}"
            else
                log_warning "distccd 服务运行中，但未监听端口 ${PORT}"
                log_info "这可能是正常的，服务可能需要更多时间初始化"
            fi
        fi
        
        # 检查 GCC 版本服务
        if systemctl is-active --quiet distcc-version; then
            log_success "✅ GCC 版本服务启动成功"
            version_ok=true
            
            # 验证端口监听
            sleep 1
            if netstat -tuln 2>/dev/null | grep -q ":3633" || ss -tuln 2>/dev/null | grep -q ":3633"; then
                log_success "✅ GCC 版本服务正在监听端口 3633"
            else
                log_warning "GCC 版本服务运行中，但未监听端口 3633"
            fi
        else
            log_warning "⚠️  GCC 版本服务启动失败"
            
            # 显示详细错误信息
            echo ""
            log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
            log_info "GCC 版本服务启动失败诊断"
            log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
            
            # 检查服务文件是否存在
            if [ ! -f /etc/systemd/system/distcc-version.service ]; then
                log_error "服务文件不存在: /etc/systemd/system/distcc-version.service"
            else
                log_success "服务文件存在"
            fi
            
            # 检查服务器脚本是否存在
            if [ ! -f /usr/local/bin/distcc-version-server.sh ]; then
                log_error "TCP 服务器脚本不存在: /usr/local/bin/distcc-version-server.sh"
            elif [ ! -x /usr/local/bin/distcc-version-server.sh ]; then
                log_error "TCP 服务器脚本不可执行"
            else
                log_success "TCP 服务器脚本存在且可执行"
            fi
            
            # 检查必要工具
            log_info "检查 TCP 服务器工具:"
            if command -v socat &> /dev/null; then
                log_success "  ✅ socat 已安装"
            elif command -v ncat &> /dev/null; then
                log_success "  ✅ ncat 已安装"
            elif command -v nc &> /dev/null; then
                log_success "  ✅ nc 已安装"
            else
                log_error "  ❌ 未找到任何可用的 TCP 服务器工具（socat/ncat/nc）"
                log_info "  安装 socat: sudo yum install socat  # 或 sudo apt install socat"
            fi
            
            # 显示服务日志
            echo ""
            log_info "最近的服务日志:"
            journalctl -u distcc-version -n 20 --no-pager 2>/dev/null || log_warning "无法读取日志"
            
            echo ""
            log_info "手动测试 TCP 服务器:"
            log_info "  sudo /usr/local/bin/distcc-version-server.sh"
            echo ""
        fi
        
        # 如果两个服务都启动成功
        if [ "$distccd_ok" = "true" ]; then
            
            # 显示监控提示（配置完成后会自动进入监控）
            echo ""
            log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
            log_info "📊 监控编译服务器"
            log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
            echo ""
            echo -e "${GREEN}管理服务:${NC}"
            echo -e "  ${CYAN}./setup-distccd.sh monitor${NC}    # 实时监控"
            echo -e "  ${CYAN}./setup-distccd.sh status${NC}     # 查看状态"
            echo -e "  ${CYAN}./setup-distccd.sh restart${NC}    # 重启服务"
            echo -e "  ${CYAN}./setup-distccd.sh stop${NC}       # 停止服务"
            echo ""
            log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
            
            return 0
        else
            retry=$((retry + 1))
            if [ $retry -lt $max_retry ]; then
                log_warning "服务启动失败，重试 $retry/$max_retry..."
                systemctl restart distccd
                sleep 3
            fi
        fi
    done
    
    # 7. 启动失败，进行详细诊断
    log_error "❌ distccd 服务启动失败"
    echo ""
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    log_info "自动诊断"
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
    # 显示服务状态
    log_info "服务状态:"
    systemctl status distccd --no-pager -l || true
    
    echo ""
    
    # 显示最近日志
    log_info "最近日志:"
    journalctl -u distccd -n 20 --no-pager || true
    
    echo ""
    
    # 检查常见问题
    log_info "检查常见问题:"
    
    # 检查 distcc 用户
    if ! id distcc &>/dev/null; then
        log_error "  ❌ distcc 用户不存在"
    else
        log_success "  ✅ distcc 用户存在"
    fi
    
    # 检查 distccd 可执行文件
    local distccd_path=$(grep 'ExecStart=' /etc/systemd/system/distccd.service | awk '{print $1}' | cut -d= -f2)
    if [ -x "$distccd_path" ]; then
        log_success "  ✅ distccd 可执行: $distccd_path"
    else
        log_error "  ❌ distccd 不可执行: $distccd_path"
    fi
    
    # 检查配置冲突
    if grep -q -- '--daemon' /etc/systemd/system/distccd.service; then
        log_error "  ❌ 发现 --daemon 参数（与 --no-detach 冲突）"
        log_info "  建议: 重新运行此脚本修复配置"
    else
        log_success "  ✅ 无参数冲突"
    fi
    
    echo ""
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    log_info "建议操作:"
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    log_info "1. 查看详细日志: journalctl -xeu distccd"
    log_info "2. 查看实时日志: journalctl -fu distccd"
    log_info "3. 重新运行脚本: sudo $0 --allowed-nets ${ALLOWED_NETS}"
    log_info "4. 手动测试 distccd:"
    log_info "   sudo -u distcc $distccd_path --no-detach --log-stderr --allow 0.0.0.0/0 --port ${PORT}"
    echo ""
    
    exit 1
}

# 显示配置信息
show_config_info() {
    local ip_addr=$(hostname -I | awk '{print $1}')
    local gcc_version=$(gcc --version | head -n1)
    
    cat << EOF

${GREEN}═══════════════════════════════════════════════════════════════${NC}
${GREEN}✅ distccd 配置完成！${NC}
${GREEN}═══════════════════════════════════════════════════════════════${NC}

${BLUE}服务信息:${NC}
  - distccd 状态: $(systemctl is-active distccd)
  - distccd 监听: 0.0.0.0:${PORT}
  - 版本服务状态: $(systemctl is-active distcc-version 2>/dev/null || echo "未安装")
  - 版本服务监听: 0.0.0.0:3633
  - 并行任务: ${JOBS}
  - 允许网络: ${ALLOWED_NETS}

${BLUE}机器信息:${NC}
  - IP地址: ${ip_addr}
  - CPU核心: $(get_cpu_cores) 核
  - 编译器: ${gcc_version}

${BLUE}主编译机配置:${NC}
  在主编译机的 ci/distcc.conf 中添加以下配置:

  ${YELLOW}DISTCC_ENABLED=yes${NC}
  ${YELLOW}DISTCC_HOSTS="localhost/16 ${ip_addr}/$(get_cpu_cores),lzo"${NC}
  ${YELLOW}DISTCC_JOBS=<根据总核心数计算>${NC}

${BLUE}验证连接:${NC}
  在主编译机上运行:
  ${YELLOW}# 测试 distccd 服务${NC}
  ${YELLOW}telnet ${ip_addr} ${PORT}${NC}
  ${YELLOW}distcc gcc -c test.c -o test.o${NC}
  
  ${YELLOW}# 测试 GCC 版本服务${NC}
  ${YELLOW}nc -w 2 ${ip_addr} 3633${NC}
  ${YELLOW}./ci/test-gcc-version-service.sh ${ip_addr}${NC}

${BLUE}查看日志:${NC}
  ${YELLOW}journalctl -xeu distccd${NC}         # distccd 日志
  ${YELLOW}journalctl -fu distccd${NC}          # 实时日志
  ${YELLOW}journalctl -xeu distcc-version${NC}  # 版本服务日志

${BLUE}管理服务:${NC}
  ${YELLOW}sudo ./ci/setup-distccd.sh status${NC}    # 查看状态
  ${YELLOW}sudo ./ci/setup-distccd.sh restart${NC}   # 重启所有服务
  ${YELLOW}sudo ./ci/setup-distccd.sh stop${NC}      # 停止所有服务
  ${YELLOW}sudo ./ci/setup-distccd.sh monitor${NC}   # 实时监控

${GREEN}═══════════════════════════════════════════════════════════════${NC}

EOF
}

# 主函数
main() {
    # 检查第一个参数是否为命令
    if [ $# -gt 0 ]; then
        case "$1" in
            monitor)
                # 监控命令不需要 root
                monitor_distccd
                exit 0
                ;;
            status)
                echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                echo "distccd 服务状态:"
                echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                systemctl status distccd
                echo ""
                echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                echo "GCC 版本服务状态:"
                echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
                systemctl status distcc-version 2>/dev/null || echo "未安装"
                exit 0
                ;;
            start)
                check_root
                systemctl start distccd
                systemctl start distcc-version 2>/dev/null || true
                log_success "distccd 服务已启动"
                log_success "GCC 版本服务已启动"
                exit 0
                ;;
            stop)
                check_root
                systemctl stop distccd
                systemctl stop distcc-version 2>/dev/null || true
                log_success "distccd 服务已停止"
                log_success "GCC 版本服务已停止"
                exit 0
                ;;
            restart)
                check_root
                systemctl stop distcc-version 2>/dev/null || true
                systemctl restart distccd
                systemctl start distcc-version 2>/dev/null || true
                log_success "distccd 服务已重启"
                log_success "GCC 版本服务已重启"
                exit 0
                ;;
            --help|-h)
                show_help
                exit 0
                ;;
            --*)
                # 以 -- 开头的是选项，继续处理
                ;;
            *)
                log_error "未知命令: $1"
                show_help
                exit 1
                ;;
        esac
    fi
    
    # 检查 root 权限（配置模式需要）
    check_root
    
    # 检查服务是否已经运行
    if systemctl is-active --quiet distccd 2>/dev/null; then
        log_success "✅ distccd 服务已在运行"
        echo ""
        log_info "服务已配置并运行中，无需重新配置"
        log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
        echo ""
        echo -e "${YELLOW}选择操作:${NC}"
        echo -e "  1) 进入监控模式（推荐）"
        echo -e "  2) 重新配置服务"
        echo -e "  3) 退出"
        echo ""
        read -p "请选择 [1-3]: " choice
        
        case "$choice" in
            1|"")
                log_info "进入监控模式..."
                sleep 1
                monitor_distccd
                exit 0
                ;;
            2)
                log_warning "将重新配置服务（当前服务会被停止并重新配置）"
                read -p "确认重新配置? [y/N]: " confirm
                if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
                    log_info "已取消"
                    exit 0
                fi
                log_info "开始重新配置..."
                ;;
            3)
                log_info "退出"
                exit 0
                ;;
            *)
                log_error "无效选择"
                exit 1
                ;;
        esac
    fi
    
    # 默认参数
    ALLOWED_NETS="0.0.0.0/0"  # 默认允许所有IP
    JOBS=$(($(get_cpu_cores) * 2))
    PORT=3632
    
    # 解析命令行参数
    while [ $# -gt 0 ]; do
        case "$1" in
            --allowed-nets)
                ALLOWED_NETS="$2"
                shift 2
                ;;
            --jobs)
                JOBS="$2"
                shift 2
                ;;
            --port)
                PORT="$2"
                shift 2
                ;;
            --help|-h)
                show_help
                exit 0
                ;;
            *)
                log_error "未知选项: $1"
                show_help
                exit 1
                ;;
        esac
    done
    
    # 显示配置
    log_info "配置参数:"
    log_info "  - 允许网络: ${ALLOWED_NETS}"
    log_info "  - 并行任务: ${JOBS}"
    log_info "  - 监听端口: ${PORT}"
    echo
    
    # 执行配置步骤
    detect_os
    install_distcc
    create_distcc_user
    setup_masquerade
    configure_systemd_service
    configure_firewall
    start_service
    show_config_info
    
    # 配置完成后，自动进入监控模式
    echo ""
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    log_success "配置完成！即将进入实时监控模式..."
    log_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo ""
    sleep 2
    
    # 启动监控
    monitor_distccd
}

# 执行主函数
main "$@"

